home *** CD-ROM | disk | FTP | other *** search
/ MacHack 1996 / MacHack 1996.toast / Hacks / Hacks '96 / Talking Telnet / source / main / menuseg.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-06-22  |  46.2 KB  |  1,718 lines  |  [TEXT/CWIE]
  1. /****************************************************************
  2. *    NCSA Telnet for the Macintosh                                *
  3. *                                                                *
  4. *    National Center for Supercomputing Applications                *
  5. *    Software Development Group                                    *
  6. *    152 Computing Applications Building                            *
  7. *    605 E. Springfield Ave.                                        *
  8. *    Champaign, IL  61820                                        *
  9. *                                                                *
  10. *    Copyright (c) 1986-1992,                                    *
  11. *    Board of Trustees of the University of Illinois                *
  12. *****************************************************************
  13. *
  14. *    Menu Handling and initialization code.
  15. *
  16. *    
  17. *    Revisions:
  18. *    7/92 Telnet 2.6 initial version: reorganized defines, put all stray globals in a struct, and
  19. *                put all cursors in a nice array.  Moved some routines to other places -    Scott Bulmahn            
  20. *
  21. *    6/94 Added support for Keypad and Function menus - Carl Bell (Baylor U.)
  22. */
  23.  
  24. #ifdef MPW
  25. #pragma segment 4
  26. #endif
  27.  
  28.  
  29. #include "wind.h"
  30. #include "menuseg.proto.h"
  31. #include "mainseg.proto.h"
  32. #include "Sets.proto.h"                /* JMB: For Saved Sets functions */
  33. #include "configure.proto.h"
  34. #include "parse.proto.h"
  35. #include "InternalEvents.h"
  36. #include "mydnr.proto.h"
  37. #include "rsinterf.proto.h"
  38. #include "network.proto.h"
  39. #include "maclook.proto.h"
  40. #include "vrrgmac.proto.h"
  41. #include "rgmp.proto.h"
  42. #include "tekrgmac.proto.h"
  43. #include "vgtek.proto.h"
  44. #include "netevent.proto.h"
  45. #include "Connections.proto.h"
  46. #include "tnae.h"
  47. #include "authencrypt.proto.h"
  48. #include "vsdata.h"
  49. #include "vsinterf.proto.h"
  50.  
  51. #include "event.proto.h"
  52. #include "macros.proto.h"
  53. #include "DlogUtils.proto.h"            /* For VersionNumber, OutlineItem, and DialogProc Protos */
  54. #include "telneterrors.h"
  55.  
  56.  
  57. #include <Printing.h>
  58. #include "printing.proto.h"
  59. #include "menuseg.proto.h"
  60. #include "translate.proto.h"
  61. #include "parse.proto.h"                // For SendNAWSinfo proto
  62. #include "keypadmenus.proto.h"
  63. #include "LinkedList.proto.h"
  64. #include "speech.proto.h"
  65.  
  66. MenuHandle
  67.     myMenus[NMENUS];        /* Menu Handles .... */
  68. static short lastMenyCommandKeys = -1; //whether last menu set had command keys
  69.  
  70. //char *tempspot;                /* temporary storage ~255 bytes malloc-ed */
  71.  
  72.  
  73. /*
  74.  * External variable declarations (those which we borrow )
  75.  *
  76.  */
  77. extern short scrn;
  78. extern Cursor *theCursors[];
  79. extern WindRec
  80.     *screens,            /* The screen array from Maclook */
  81.     *ftplog;                    /* The FTP log screen from Maclook */
  82. extern    short    nNational;
  83.  
  84. void CloseCaptureFile(short w)
  85. {
  86.     VSclosecapture(w);                                /* BYU 2.4.18 */
  87.     CheckItem(myMenus[Emul], EMcapture,FALSE);        /* BYU 2.4.18 */
  88. }
  89.  
  90. /*    portsOpen()    - Count the number of ports open. Returns 3 different answers
  91.  *                  0= no ports at all, 1= at least active, -1= ports/none active. */
  92. short    portsOpen(void)
  93. {
  94.     short pnum;
  95.  
  96.     pnum=TelInfo->numwindows-1;
  97.     if (pnum<0)  return(0);
  98.     while (pnum>=0) 
  99. //        if (!screens[pnum--].active && !screens[pnum+1].corpse) return(1);
  100.         // corpse status now part of active flag
  101.         if (screens[pnum--].active == CNXN_ACTIVE) return(1);
  102.     return(-1);
  103. }
  104.  
  105. void switchToOptionMenus(Boolean useOptionedStuff)
  106. {
  107.      Str255 theMenuItem;
  108.      short whichString;
  109.      if (useOptionedStuff)
  110.          whichString = CLOSE_ALL_MENU_ITEM;
  111.      else
  112.          whichString = CLOSE_MENU_ITEM;
  113.     
  114.      GetIndString(theMenuItem,MISC_STRINGS,whichString);
  115.     
  116.      SetItem(myMenus[Fil],FLclose,theMenuItem);
  117. }
  118.  
  119. void switchToShiftMenus(Boolean useShiftStuff)
  120. {
  121.      Str255 theMenuItem;
  122.      short whichString;
  123.      if (useShiftStuff)
  124.          whichString = PREVIOUS_SESSION_STRING;
  125.      else
  126.          whichString = NEXT_SESSION_STRING;
  127.     
  128.      GetIndString(theMenuItem,MISC_STRINGS,whichString);
  129.      SetItem(myMenus[Conn],COnext,theMenuItem);
  130.          
  131. }
  132. void    AdjustMenus(void)
  133. {
  134.     short        i;
  135.     WindowPtr    wind;
  136.     
  137.     if ((wind = FrontWindow()) != NULL && (((WindowPeek)wind)->windowKind >= userKind))
  138.         EnableItem( myMenus[Fil],FLclose);
  139.     else
  140.         DisableItem( myMenus[Fil],FLclose);
  141.         
  142.     if ((i=portsOpen()) <1) {
  143.         DisableItem( myMenus[Fil],FLsave);
  144.         DisableItem( myMenus[Fil],FLprint);
  145.         DisableItem( myMenus[Edit],EDcut);
  146.         DisableItem( myMenus[Edit],EDundo);
  147.         DisableItem( myMenus[Edit],EDclear);
  148.         DisableItem( myMenus[Edit],EDcopy);
  149.         DisableItem( myMenus[Edit],EDcopyt);
  150.  
  151.  
  152.         DisableItem( myMenus[Emul],EMbs);
  153.         DisableItem( myMenus[Emul],EMdel);
  154.         DisableItem( myMenus[Emul],EMecho);
  155.         DisableItem( myMenus[Emul],EMwrap);
  156.         DisableItem( myMenus[Emul],EMscroll);
  157.         DisableItem( myMenus[Emul],EMreset);
  158.         DisableItem ( myMenus[Emul],EMjump);
  159.         DisableItem ( myMenus[Emul],EMpage);
  160.         DisableItem ( myMenus[Emul],EMclear);    /* BYU 2.4.14 */
  161.         DisableItem ( myMenus[Emul],EMscreensize);
  162.         DisableItem ( myMenus[Emul],EMsetup);
  163.         DisableItem ( myMenus[Emul],EMfont);
  164.         DisableItem ( myMenus[Emul],EMsize);
  165.         DisableItem ( myMenus[Emul],EMcolor);
  166.         DisableItem ( myMenus[Emul],EMAnsiColor);
  167.         DisableItem ( myMenus[Emul],EMcapture);    /* BYU 2.4.18 */
  168.  
  169.         DisableItem( myMenus[Net ],NEftp);
  170.         DisableItem( myMenus[Net ],NEip);
  171.         DisableItem( myMenus[Net ],NEayt);
  172.         DisableItem( myMenus[Net ],NEao);
  173.         DisableItem( myMenus[Net ],NEinter);
  174.         DisableItem( myMenus[Net ],NEec);
  175.         DisableItem( myMenus[Net ],NEel);
  176.         DisableItem( myMenus[Net ],NEscroll);
  177.  
  178.         if (TelInfo->ScrlLock) {
  179.             TelInfo->ScrlLock=0;
  180.             CheckItem(myMenus[Net ], NEscroll,FALSE);
  181.             }
  182.         }
  183.     else {
  184.         EnableItem ( myMenus[Fil],FLsave);
  185.         EnableItem ( myMenus[Emul],EMbs);
  186.         EnableItem ( myMenus[Emul],EMdel);
  187.         EnableItem ( myMenus[Emul],EMecho);
  188.         EnableItem ( myMenus[Emul],EMwrap);
  189.         if (nNational > 0) {
  190.             EnableItem ( myMenus[National], 0);
  191.             }
  192.         EnableItem ( myMenus[Emul],EMscroll);
  193.         EnableItem ( myMenus[Emul],EMreset);
  194.         EnableItem ( myMenus[Emul],EMjump);
  195.         EnableItem ( myMenus[Emul],EMpage);
  196.         EnableItem ( myMenus[Emul],EMclear);    /* BYU 2.4.14 */
  197.         EnableItem ( myMenus[Emul],EMscreensize);
  198.         EnableItem ( myMenus[Emul],EMsetup);
  199.         EnableItem ( myMenus[Emul],EMfont);
  200.         EnableItem ( myMenus[Emul],EMsize);
  201.         EnableItem ( myMenus[Emul],EMcapture);    /* BYU 2.4.18 */
  202.     
  203.         if (TelInfo->haveColorQuickDraw) 
  204.         {
  205.             EnableItem ( myMenus[Emul],EMcolor);
  206.             EnableItem ( myMenus[Emul],EMAnsiColor);
  207.         }
  208.         EnableItem ( myMenus[Net ],NEftp);
  209.         EnableItem ( myMenus[Net ],NEip);
  210.         EnableItem ( myMenus[Net ],NEayt);
  211.         EnableItem ( myMenus[Net ],NEao);
  212.         EnableItem ( myMenus[Net ],NEinter);
  213.         EnableItem ( myMenus[Net ],NEec);
  214.         EnableItem ( myMenus[Net ],NEel);
  215.         EnableItem ( myMenus[Net ],NEscroll);
  216.     }
  217.     
  218. #ifdef    SPEECH
  219.     {
  220.         short    w;
  221.         Boolean    selected;
  222.         
  223.         w = WindowPtr2ScreenIndex(wind);
  224.         selected = 0 <= w ? RSTextSelected(w) : false;
  225.         
  226.         AdjustSpeechMenu(selected);
  227.         
  228.     }
  229. #endif
  230.  
  231. }
  232.  
  233. /*    switchMenus( which) - Switch from our current menus to the key menus (1)
  234.  *                          or the normal menus (0). */
  235. void switchMenus(short which)
  236. {
  237.     short i;
  238.         
  239.     if (lastMenyCommandKeys != which)
  240.     {
  241.         lastMenyCommandKeys = which;
  242.         DeleteMenu( fileMenu);                    /* Take them from the menu bar */
  243.         DeleteMenu( editMenu);
  244.         DeleteMenu( termMenu);
  245.         DeleteMenu(  netMenu);
  246.         DeleteMenu(  keyMenu);                /* Baylor */
  247.         DeleteMenu( funcMenu);                /* Baylor */
  248.         DeleteMenu(NfileMenu);                
  249.         DeleteMenu(NeditMenu);
  250.         DeleteMenu(NtermMenu);
  251.         DeleteMenu(NnetMenu);
  252.  
  253.         if (which) 
  254.         {
  255.             myMenus[Fil ] = GetMenu(NfileMenu);
  256.             myMenus[Edit] = GetMenu(NeditMenu);
  257.             myMenus[Emul] = GetMenu(NtermMenu);
  258.             myMenus[Net ] = GetMenu(NnetMenu );
  259.             myMenus[Keypad] = GetMenu(keyMenu);            /* Baylor */
  260.             myMenus[Function] = GetMenu(funcMenu);        /* Baylor */
  261.     
  262.             DelMenuItem(myMenus[Conn],COnext);
  263.             InsMenuItem(myMenus[Conn],(StringPtr)"\017Next Session/N\0",0);
  264.             }
  265.         else 
  266.         {
  267.             myMenus[Fil ] = GetMenu(fileMenu);
  268.             myMenus[Edit] = GetMenu(editMenu);
  269.             myMenus[Emul] = GetMenu(termMenu);
  270.             myMenus[Net ] = GetMenu( netMenu);
  271.             myMenus[Keypad] = GetMenu(keyMenu);            /* Baylor */
  272.             myMenus[Function] = GetMenu(funcMenu);        /* Baylor */
  273.     
  274.             DelMenuItem(myMenus[Conn],COnext);
  275.             InsMenuItem(myMenus[Conn],(StringPtr)"\015Next Session\0",0);
  276.         }
  277.     }
  278.     for(i=1; i<Conn; i++)
  279.         InsertMenu( myMenus[i], connMenu);    /* Put them in the menu bar */
  280.  
  281.     if (gApplicationPrefs->KeyPadAndFuncMenus) {            /* Baylor */
  282.         InsertMenu(myMenus[Keypad], 0);                        /* Baylor */
  283.         InsertMenu(myMenus[Function], 0);                    /* Baylor */
  284.         }
  285.  
  286.     AdjustMenus();            /* Hilite the right stuff */
  287.  
  288.     if (TelInfo->MacBinary)
  289.         CheckItem(myMenus[Fil],FLbin,TRUE);        /* Check MacBinary ... */
  290.     else
  291.         CheckItem(myMenus[Fil],FLbin,FALSE);
  292.  
  293.     if (TelInfo->ftplogon)
  294.         CheckItem(myMenus[Fil],FLlog,TRUE);        /* and the log .... */
  295.     else
  296.         CheckItem(myMenus[Fil],FLlog,FALSE);
  297.  
  298.     if (TelInfo->ScrlLock)                                 /* and the Suspend network ... */
  299.         CheckItem(myMenus[Net], NEscroll,TRUE);
  300.     else 
  301.         CheckItem(myMenus[Net], NEscroll,FALSE);
  302.  
  303.     if (TelInfo->numwindows>0)                            /* and set the BSDEL flag */
  304.         CheckItem(myMenus[Emul], EMbs+screens[scrn].bsdel,FALSE);
  305.  
  306.     DrawMenuBar();                                /* Draw what we have done */
  307.  
  308.     SetupOpSpecSubmenu(myMenus[OpSpec]);
  309.  
  310.     if (!TelInfo->haveColorQuickDraw)
  311.         DisableItem( myMenus[Emul], EMcolor);
  312.  
  313. }
  314.  
  315. /*    setupmenu - Set up (load) all menus and prepare menu bar.
  316.  *                set default check marks. */
  317. void setupmenu(short def)
  318. {
  319.     lastMenyCommandKeys = def;
  320.     myMenus[0] = GetMenu(appleMenu);                /* Get all of our friendly menus */
  321.     myMenus[Conn] = GetMenu(connMenu);
  322.     myMenus[Font] = GetMenu(fontMenu);
  323.     myMenus[Sizem] = GetMenu(sizeMenu);
  324.     myMenus[OpSpec] = GetMenu(opspecMenu);
  325.     myMenus[PrefsSub] = GetMenu(prefsMenu);
  326.     myMenus[National] = GetMenu(transMenu);
  327.     myMenus[Keypad] = GetMenu(keyMenu);            /* Baylor */
  328.     myMenus[Function] = GetMenu(funcMenu);        /* Baylor */
  329.     myMenus[Fil ] = GetMenu(NfileMenu);
  330.     myMenus[Edit] = GetMenu(NeditMenu);
  331.     myMenus[Emul] = GetMenu(NtermMenu);
  332.     myMenus[Net ] = GetMenu(NnetMenu );
  333. #ifdef    SPEECH
  334.     myMenus[Speech] = GetMenu(speechMenu);
  335. #endif    /* SPEECH */
  336.  
  337.     AddResMenu(myMenus[0], 'DRVR');                    /* Add in the DA's */
  338.  
  339.     InsertMenu(myMenus[0], 0);                        /* Insert the Menus into the bar */
  340.     InsertMenu(myMenus[Conn], 0);
  341. #ifdef    SPEECH
  342.     InsertMenu(myMenus[Speech], BuildSpeechMenu(myMenus[Speech]) ? 0 : -1);
  343. #endif    /* SPEECH */
  344.     if (gApplicationPrefs->KeyPadAndFuncMenus) {    /* Baylor */
  345.         InsertMenu(myMenus[Keypad], 0);                /* Baylor */
  346.         InsertMenu(myMenus[Function], 0);            /* Baylor */
  347.         }
  348.     InsertMenu(myMenus[Font], -1);
  349.     InsertMenu(myMenus[Sizem], -1);
  350.     InsertMenu(myMenus[OpSpec], -1);
  351.     InsertMenu(myMenus[National], -1);
  352.     InsertMenu(myMenus[PrefsSub], -1);
  353.     
  354.     addMonoSpacedFonts(myMenus[Font]);
  355.     SetupOpSpecSubmenu(myMenus[OpSpec]);
  356.     switchMenus(def);
  357.  
  358. }
  359.  
  360. void addMonoSpacedFonts(MenuHandle theMenu)
  361. {
  362.     Boolean doItAll = FALSE;
  363.     Handle    theGoodFonts, theBadFonts;
  364.     short    numGoodFonts, numBadFonts,numFontsInMenu;
  365.     short menuIndex;
  366.     Str255 fontListName,currentFontName;
  367.     
  368.     //here begins the caching of fonts to save time caculating proportionality
  369.     UseResFile(TelInfo->SettingsFile);
  370.     
  371.     theGoodFonts = Get1Resource('STR#',4000); //the good fonts
  372.     if (!theGoodFonts)
  373.     {
  374.         UseResFile(TelInfo->ApplicationFile);
  375.         theGoodFonts = Get1Resource('STR#',4000);
  376.         theBadFonts = Get1Resource('STR#',5000);
  377.         DetachResource(theGoodFonts);
  378.         DetachResource(theBadFonts);
  379.         UseResFile(TelInfo->SettingsFile);
  380.         AddResource(theGoodFonts,'STR#',4000,"\pGood Fonts");
  381.         AddResource(theBadFonts,'STR#',5000,"\pBad Fonts");
  382.     }
  383.     else
  384.         theBadFonts = Get1Resource('STR#',5000);
  385.  
  386. redoTheList:            
  387.  
  388.     numGoodFonts = *(short *)(*theGoodFonts);
  389.     if (numGoodFonts == 0)
  390.         doItAll = TRUE; //we haven't created a list of fonts yet
  391.     else
  392.         numBadFonts = *(short *)(*theBadFonts);
  393.  
  394.     AddResMenu(theMenu,'FONT'); //add them all here
  395.     numFontsInMenu = CountMItems(theMenu);
  396.     if (numFontsInMenu != (numBadFonts + numGoodFonts))
  397.     {
  398.         SetHandleSize(theGoodFonts,2);
  399.         *((short *)*theGoodFonts) = 0; 
  400.         SetHandleSize(theBadFonts,2);
  401.         *((short *)*theBadFonts) = 0; 
  402.         doItAll = TRUE;
  403.     }
  404.     if (!doItAll) //we have a list already
  405.     {
  406.         short goodFontIndex, badFontIndex;
  407.         goodFontIndex = badFontIndex = 1;
  408.         
  409.         for (menuIndex = 1; menuIndex <=  numFontsInMenu; menuIndex++)
  410.         {    //look at each font, see if its bad, good, or new
  411.             GetItem(theMenu,menuIndex,currentFontName);
  412.             GetIndString(fontListName,5000,badFontIndex);
  413.             if (EqualString(currentFontName,fontListName,TRUE,FALSE))
  414.             {
  415.                 DelMenuItem(theMenu,menuIndex); //remove the bad font from the menu
  416.                 numFontsInMenu--; 
  417.                 menuIndex--;
  418.                 badFontIndex++;
  419.             }
  420.             else
  421.             {    
  422.                 GetIndString(fontListName,4000,goodFontIndex);
  423.                 if (EqualString(currentFontName,fontListName,TRUE,FALSE))
  424.                     goodFontIndex++;
  425.                 else //its a new font, and we didn't expect it; this means there were an equal
  426.                 {    //number of fonts removed and added.  Lets start over. 
  427.                     short numberInMenu;
  428.                     numberInMenu = CountMItems(theMenu);
  429.                     for (;numberInMenu > 0; numberInMenu--)
  430.                         DelMenuItem(theMenu,numberInMenu);//clear the menu
  431.                     SetHandleSize(theGoodFonts,2);//clear the lists
  432.                     SetHandleSize(theBadFonts,2);
  433.                     
  434.                     goto redoTheList;
  435.                 }
  436.             }
  437.         }
  438.     }        
  439.     else //create a new list
  440.     {
  441.         DialogPtr     dtemp;
  442.         dtemp = GetNewMyDialog(130, NULL, kInFront, (void *)SecondThirdCenterDialog);    /* opening dialog */
  443.         DrawDialog(dtemp);
  444.         
  445.                                             
  446.         for (menuIndex = 1; menuIndex <=  numFontsInMenu; menuIndex++)
  447.         {
  448.             GetItem(theMenu,menuIndex,currentFontName);
  449.             if (!isMonospacedFont(currentFontName))
  450.             {
  451.                 DelMenuItem(theMenu,menuIndex); //remove the bad font from the menu
  452.                 numFontsInMenu--; 
  453.                 menuIndex--;
  454.                 PtrAndHand(currentFontName,theBadFonts,currentFontName[0]+1);//add it to the bad list
  455.                 (*(short *)(*theBadFonts))++;
  456.             }
  457.             else
  458.             {
  459.                 PtrAndHand(currentFontName,theGoodFonts,currentFontName[0]+1);//add it to the good list
  460.                 (*(short *)(*theGoodFonts))++;
  461.             }
  462.         }
  463.         DisposDialog(dtemp);    
  464.     }    
  465.     ChangedResource(theGoodFonts);
  466.     ChangedResource(theBadFonts);
  467.     ReleaseResource(theGoodFonts);
  468.     ReleaseResource(theBadFonts);
  469.     UpdateResFile(TelInfo->SettingsFile);
  470. }
  471.  
  472. Boolean isMonospacedFont(Str255 theFont)
  473. {
  474.     Boolean haveNonRomanScripts,thisOneIsMonospaced = FALSE, doRomanTest = FALSE;
  475.     short fond;
  476.     long tempLong;
  477.     //GrafPtr tempPort, savedPort;
  478.  
  479.     //first, open a temporary port to test CharWidth
  480.     //tempPort = (GrafPtr)myNewPtrCritical(sizeof(GrafPort));
  481.     //GetPort(&savedPort);
  482.     //OpenPort(tempPort);
  483.  
  484.     tempLong = GetScriptManagerVariable(smEnabled);    //this returns number of scripts enable
  485.     haveNonRomanScripts = (tempLong > 1); //if there is one, its roman
  486.     GetFNum(theFont,&fond);
  487.     if (haveNonRomanScripts)
  488.     {
  489.         long thisScriptEnabled;
  490.         ScriptCode scriptNumber;
  491.         
  492.         scriptNumber = FontToScript(fond);
  493.         if (scriptNumber != 0) //if its non-roman
  494.         {
  495.             thisScriptEnabled = GetScriptVariable(scriptNumber,smScriptEnabled);
  496.             if (thisScriptEnabled)
  497.             {
  498.                 //check if this font is the preferred monospaced font for its script
  499.                 long theSizeAndFond;
  500.                 short thePreferredFond;
  501.                 
  502.                 theSizeAndFond = GetScriptVariable(scriptNumber, smScriptMonoFondSize);
  503.                 thePreferredFond = theSizeAndFond >> 16; //high word is fond 
  504.                 thisOneIsMonospaced = (thePreferredFond == fond);
  505.             }
  506.             else
  507.                 thisOneIsMonospaced = FALSE; //this font's script isn't enabled
  508.         }
  509.         else
  510.             doRomanTest = TRUE;
  511.     }
  512.     else
  513.         doRomanTest = TRUE;
  514.         
  515.     if (doRomanTest)
  516.     {
  517.         TextFont(fond);
  518.         thisOneIsMonospaced = (CharWidth('W') == CharWidth('.'));
  519.     }
  520.     //SetPort(savedPort);
  521.     //ClosePort(tempPort);
  522.     //DisposePtr((Ptr)tempPort);
  523.     return(thisOneIsMonospaced);
  524. } 
  525.  
  526. void CheckOpSpecSubmenu(void)
  527. {
  528.     short numItems;
  529.     UseResFile(TelInfo->SettingsFile);
  530.     numItems = Count1Resources(SESSIONPREFS_RESTYPE);
  531.     if (CountMItems(myMenus[OpSpec]) != numItems)
  532.         SetupOpSpecSubmenu(myMenus[OpSpec]);
  533. }
  534.  
  535. void SetupOpSpecSubmenu(MenuHandle theMenu)
  536. {
  537.     short            scratchshort,numberofitems;
  538.     LinkedListNode    *theHead;    
  539.     scratchshort = CountMItems(theMenu);
  540.     for (; scratchshort>0; scratchshort--) DelMenuItem(theMenu, scratchshort);
  541.     
  542.     UseResFile(TelInfo->SettingsFile);
  543.     numberofitems = Count1Resources(SESSIONPREFS_RESTYPE);
  544.     if (numberofitems)
  545.     {    
  546.         theHead = createSortedList(SESSIONPREFS_RESTYPE,numberofitems,"\p<Default>"); //now we have a sorted linked list of the names
  547.         addListToMenu(theMenu,theHead);
  548.         deleteList(&theHead);
  549.     }
  550. }
  551.  
  552. /*    updateMenuChecks() - update the check marks for file transfer
  553.  *                         (MacBinary) */
  554.  
  555. void updateMenuChecks( void)
  556. {
  557.     if (TelInfo->MacBinary)
  558.         CheckItem(myMenus[Fil],FLbin,TRUE);        /* Check MacBinary ... */
  559.     else
  560.         CheckItem(myMenus[Fil],FLbin,FALSE);
  561. }
  562.  
  563. /*    DisplayMacBinary()    - Sets the macbinary check mark according to the MacBinary flag */
  564. void DisplayMacBinary( void)
  565. {
  566.     if (TelInfo->MacBinary)
  567.         CheckItem(myMenus[Fil],FLbin,TRUE);        /* Check MacBinary ... */
  568.     else
  569.         CheckItem(myMenus[Fil],FLbin,FALSE);
  570. }
  571.  
  572. /*CheckFonts()        - Place checkmarks and outlines on the appropriate
  573.  *                          menu items for the fonts */
  574. void CheckFonts(void)
  575. {
  576.     short     i, fsiz, fnum;
  577.     long    itemFontSize;
  578.     Str255     temp, itemString;
  579.  
  580.     RSgetfont( screens[scrn].vs, &fnum, &fsiz);
  581.     GetFontName(fnum, temp);
  582.     
  583.     for(i=1; i<= CountMItems( myMenus[Font]); i++)
  584.         {
  585.         GetItem( myMenus[Font], i, itemString);
  586.         if (EqualString(temp, itemString, FALSE, FALSE))
  587.             CheckItem( myMenus[Font], i, TRUE);            /* Check the current font */
  588.         else
  589.             CheckItem( myMenus[Font], i, FALSE);
  590.         }
  591.     
  592.     for(i=1; i<=CountMItems( myMenus[Sizem]); i++) {
  593.         GetItem( myMenus[Sizem], i, itemString);            /* JMB 2.6 -- Much safer to do it */
  594.         StringToNum(itemString, &itemFontSize);            /*                this way! */
  595.  
  596.         if (fsiz == (short)itemFontSize)
  597.             CheckItem( myMenus[Sizem], i, TRUE);            /* Check Our Current Size */
  598.         else
  599.             CheckItem( myMenus[Sizem], i, FALSE);
  600.  
  601.         if (RealFont( fnum, (short)itemFontSize))        /* Outline All Available REAL Sizes */
  602.             SetItemStyle( myMenus[Sizem], i, outline);
  603.         else
  604.             SetItemStyle( myMenus[Sizem], i, 0);
  605.         }
  606. }
  607.  
  608. /*    applAbout - display the about dialog for the application.*/
  609. void applAbout( void)
  610. {
  611.     DialogPtr About;
  612.     short itemhit;
  613.  
  614.     About=GetNewMyDialog( AboutDLOG, (Ptr) 0L,(WindowPtr) -1L, (void *)ThirdCenterDialog);
  615.     if (About) {
  616.         UItemAssign( About, 2, VersionNumberUPP);
  617.         ModalDialog(NULL, &itemhit);
  618.         DisposDialog(About);
  619.         }
  620. }
  621.  
  622. short ReallyClose( short scrn)
  623. {
  624.     DialogPtr    dtemp;
  625.     short        item;
  626.     Str255        scratchPstring;
  627.     
  628.     SetCursor(theCursors[normcurs]);
  629.  
  630.     GetWTitle(screens[scrn].wind, scratchPstring);
  631.     ParamText(scratchPstring, NULL, NULL, NULL);
  632.     
  633.     dtemp = GetNewMyDialog( CloseDLOG, NULL, kInFront, (void *)ThirdCenterDialog);
  634.  
  635.     item = DLOGCancel +1;
  636.     while (item> DLOGCancel)
  637.         ModalDialog(DLOGwOK_CancelUPP, &item);
  638.  
  639.     DisposDialog( dtemp);
  640.  
  641.     updateCursor(1);
  642.     
  643.     if (item == DLOGCancel) return(0);
  644.  
  645.     return(1);
  646. }
  647.  
  648. PicHandle RGtoPICT(short i)
  649. {
  650.     short j;
  651.     PicHandle tpic;
  652.     Rect trect;
  653.  
  654.     SetRect(&trect,0,0,384,384);
  655.     j=VGnewwin(TEK_DEVICE_PICTURE,VGgetVS(i));            /* NCSA 2.5: get the right VS */
  656.     RGMPsize( &trect );
  657.     VGzcpy( i, j);                /* Love dat zm factr */
  658.     tpic=OpenPicture(&trect);
  659.     ClipRect(&trect);
  660.     
  661.     VGredraw(i,j);
  662.     ClosePicture();
  663.     VGclose(j);
  664.  
  665.     return(tpic);
  666. }
  667.  
  668. /* 
  669.  * copyGraph    - Copy the current graphics screen.
  670.  *            dnum - the number of the drawing to copy .
  671.  */
  672. void copyGraph( short dnum)
  673. {
  674.     long tlong;                    /* Temporary Variable */
  675.     PicHandle tpic;                /* Mental picture of the thing */
  676.  
  677.     tpic=RGtoPICT(dnum);            /* Get the picture */
  678.     tlong=ZeroScrap();                /* Nobody else can live here */
  679.     HLock((Handle) tpic);                    /* Lock it for Puting */
  680.     tlong=PutScrap(GetHandleSize((Handle) tpic),'PICT', (Ptr) *tpic);    /* Store as a PICT */
  681.     HUnlock((Handle) tpic);                    /* Unlock so we can toss it */
  682.     KillPicture(tpic);                /* Kill the picture..... */
  683. }                
  684.  
  685. /* 
  686.  * copyText    - Copy the current selection on the virtual screen
  687.  *            vs - the number of the virtual screen to copy from
  688.  */
  689.  
  690. void copyText( short vs)
  691. {
  692.     char **charh;            /* where to store the characters */
  693.     long tlong;                /* Necessary temporary variable */
  694.  
  695.     tlong=ZeroScrap();        /* This Scrap aint big enough for the both of us */
  696.  
  697.     charh=RSGetTextSel(vs,0);        /* Get the text selection */
  698.  
  699.     if (charh == (char **)-1L)
  700.         OutOfMemory(400);
  701.     else if (charh != (char **)0L) {    /* BYU LSC - Can't do anything without characters */
  702.         HLock(charh);                /* Lock for putting */
  703.         tlong=PutScrap(GetHandleSize(charh),'TEXT',*charh);
  704.                                     /* Put it as a TEXT resource */
  705.         HUnlock(charh);                /* Unlock for disposal */
  706.         DisposHandle(charh);        /* Kill the chars */
  707.         }
  708. }
  709.  
  710. /* 
  711.  * copyTable   - Copy the current selection on the virtual screen
  712.  *            vs - the number of the virtual screen to copy from
  713.  */
  714.  
  715. void copyTable( short vs)
  716. {
  717.     char **charh;            /* where to store the characters */
  718.     long tlong;                /* Necessary temporary variable */
  719.  
  720.     tlong=ZeroScrap();        /* This Scrap aint big enough for the both of us */
  721.  
  722.     charh=RSGetTextSel(vs, gApplicationPrefs->CopyTableThresh);        /* Get the text selection */
  723.  
  724.     if (charh>(char **)0L) {                    /* BYU LSC - Can't do anything without characters */
  725.         HLock(charh);                /* Lock for putting */
  726.         tlong=PutScrap(GetHandleSize(charh),'TEXT',*charh);
  727.                                     /* Put it as a TEXT resource */
  728.         HUnlock(charh);                /* Unlock for disposal */
  729.         DisposHandle(charh);        /* Kill the chars */
  730.         }
  731.     else putln("No characters to copy darn it!");
  732. }
  733.  
  734. /*
  735.  *    paste - Paste the resource from the scrap into the current WIND, if
  736.  *            and only if it is really text
  737.  */
  738.  
  739. void paste( void)
  740. {
  741.     long
  742.         off,                /* offset */
  743.         length;                /* the lenght of what is on the Scrap */
  744.  
  745.     if (screens[scrn].clientflags & PASTE_IN_PROGRESS) {  // One paste at a time, please
  746.         SysBeep(4);
  747.         return;
  748.         }
  749.         
  750.     /* Flush the buffer if necessary */ //CCP fix for linemode
  751.     if (screens[scrn].kblen>0)
  752.     {    
  753.         netpush(screens[scrn].port);
  754.         netwrite( screens[scrn].port, screens[scrn].kbbuf,
  755.                     screens[scrn].kblen);    
  756.         screens[scrn].kblen=0;
  757.     }
  758.  
  759.     if (GetScrap(0L, 'TEXT', &off)<=0L)        /* If there are no TEXT res's */
  760.             return;                        /* then we can't paste it */
  761.  
  762.     screens[scrn].outhand=myNewHandle(0L);    /* create a handle to put chars in */
  763.  
  764.     length= GetScrap( screens[scrn].outhand, 'TEXT',&off);
  765.                                             /* Store the scrap into the handle */
  766.     screens[scrn].outlen = length;            /* Set the length */
  767.     HLock(screens[scrn].outhand);            /* Lock the Handle down for safety */
  768.     screens[scrn].outptr=*screens[scrn].outhand;    /* Set the pointer */
  769.  
  770.     screens[scrn].clientflags |= PASTE_IN_PROGRESS;
  771.     screens[scrn].incount = 0;
  772.     screens[scrn].outcount = 0;
  773.     
  774.     trbuf_mac_nat((unsigned char *)screens[scrn].outptr,screens[scrn].outlen, screens[scrn].national);    /* LU: translate to national chars */
  775.  
  776.     pasteText( scrn);    /* BYU LSC - routine to paste to net, w/echo if neccessary */
  777. }
  778.  
  779. void displayStatus(short n)
  780. {
  781.     DialogPtr        dptr;
  782.     short            item;
  783.     Str255            scratchPstring,anotherString;
  784.     
  785.     SetCursor(theCursors[normcurs]);
  786.     
  787.     switch(screens[n].active) {
  788.         case CNXN_ISCORPSE:
  789.             GetWTitle(screens[n].wind, scratchPstring);
  790.             GetIndString(anotherString,MISC_STRINGS,AWAITING_DISMISSAL_STRING);
  791.             ParamText( scratchPstring, anotherString, NULL, NULL);
  792.             break;
  793.         case CNXN_OPENING:
  794.             GetIndString(anotherString,MISC_STRINGS,BEING_OPENED_STRING);
  795.             ParamText( screens[n].machine,anotherString, NULL, NULL);
  796.             break;
  797.         default:
  798.             GetIndString(anotherString,MISC_STRINGS,BEING_LOOKED_UP);
  799.             ParamText( screens[n].machine,anotherString, NULL, NULL);
  800.         }
  801.  
  802.     dptr = GetNewMyDialog( StatusDLOG, NULL, kInFront, (void *)ThirdCenterDialog);
  803.  
  804.     item = DLOGCancel+1;
  805.     while (item > DLOGCancel)
  806.         ModalDialog(DLOGwOK_CancelUPP, &item);
  807.  
  808.     updateCursor(1);
  809.     
  810.     if (item == DLOGCancel) {
  811.         netclose(screens[n].port);
  812.         destroyport( n);
  813.         }    
  814.  
  815.     DisposDialog(dptr);
  816. }
  817.  
  818. /*
  819.  *    changeport - handle the menu updates for changing from one port to another
  820.  */
  821. void changeport(short oldprt, short newprt)
  822. {
  823.  
  824.     //sprintf(tempspot,"oldscrn: %d, newscrn: %d",oldprt,newprt); putln(tempspot);
  825.     
  826.     if (screens[oldprt].active == CNXN_ACTIVE) 
  827.         CheckItem(myMenus[Conn], oldprt + FIRST_CNXN_ITEM, FALSE);        /* Adjust Conn menu */
  828.     CheckItem(myMenus[Conn], newprt + FIRST_CNXN_ITEM, TRUE);
  829.  
  830.     CheckItem(myMenus[Emul], EMbs,FALSE);                        /* Adjust BS */
  831.     CheckItem(myMenus[Emul], EMdel,FALSE);
  832.     CheckItem(myMenus[Emul], EMbs+screens[newprt].bsdel,TRUE);    /* and DEL */
  833.  
  834.     if (screens[newprt].tektype < 0) {    // TEK is inhibited
  835.         DisableItem(myMenus[Emul],EMclear);
  836.         DisableItem(myMenus[Emul],EMpage);
  837.         }
  838.     else {
  839.         EnableItem(myMenus[Emul],EMclear);
  840.         EnableItem(myMenus[Emul],EMpage);
  841.     
  842.         if (screens[newprt].tekclear)                /* BYU 2.4.8 */
  843.             CheckItem(myMenus[Emul],EMclear,TRUE);    /* BYU 2.4.8 */
  844.         else                                         /* BYU 2.4.8 */
  845.             CheckItem(myMenus[Emul],EMclear,FALSE);    /* BYU 2.4.8 */
  846.         }
  847.         
  848.     if (screens[newprt].ESscroll)
  849.         CheckItem(myMenus[Emul],EMscroll,TRUE);
  850.     else 
  851.         CheckItem(myMenus[Emul],EMscroll,FALSE);
  852.  
  853.     if (screens[newprt].echo)                     /* LOCAL ECHO */
  854.         CheckItem(myMenus[Emul],EMecho,TRUE);
  855.     else                                         /* REMOTE ECHO */
  856.         CheckItem(myMenus[Emul],EMecho,FALSE);
  857.         
  858.     if (screens[newprt].wrap)                     /* wrap on */
  859.         CheckItem(myMenus[Emul],EMwrap,TRUE);
  860.     else                                         /* wrap off */
  861.         CheckItem(myMenus[Emul],EMwrap,FALSE);
  862.  
  863.     if (VSiscapturing(screens[newprt].vs))                /* BYU 2.4.18 */
  864.         CheckItem(myMenus[Emul], EMcapture,TRUE);        /* BYU 2.4.18 */
  865.     else                                                /* BYU 2.4.18 */
  866.         CheckItem(myMenus[Emul], EMcapture,FALSE);        /* BYU 2.4.18 */
  867.  
  868.     if (screens[newprt].arrowmap)                        /* JMB */
  869.         CheckItem(myMenus[Emul],EMarrowmap, TRUE);        /* JMB */
  870.     else                                                /* JMB */
  871.         CheckItem(myMenus[Emul],EMarrowmap, FALSE);        /* JMB */
  872.         
  873.     if (screens[newprt].pgupdwn)                        /* JMB */
  874.         CheckItem(myMenus[Emul],EMpgupdwn, TRUE);        /* JMB */
  875.     else                                                /* JMB */
  876.         CheckItem(myMenus[Emul],EMpgupdwn, FALSE);        /* JMB */
  877.     
  878.     scrn=newprt;
  879.  
  880.     CheckFonts();
  881.  
  882.     CheckNational(screens[newprt].national);
  883. }
  884.  
  885. // Returns TRUE if the user cancelled the quit
  886. Boolean    HandleQuit(void)
  887. {
  888.     short    i;
  889.     Boolean liveConnections = FALSE, die = TRUE;
  890.     
  891.     if (TelInfo->numwindows>0) 
  892.     {
  893.         for(i = 0; i < MaxSess; i++)
  894.         {
  895.             if ((screens[i].active == CNXN_ACTIVE)||(screens[i].active == CNXN_OPENING))
  896.                 liveConnections = TRUE;
  897.         }
  898.         if (liveConnections)
  899.             die = AskUserAlert(REALLY_QUIT_QUESTION, FALSE);
  900.         
  901.         if (die) 
  902.         {
  903.             for (i = TelInfo->numwindows - 1; i >= 0; i--) 
  904.             {
  905.                 netclose(screens[i].port);
  906.                 destroyport(i);
  907.             }
  908.         }
  909.         else
  910.             return (TRUE);
  911.      }
  912.     if (gApplicationPrefs->destroyKTickets)
  913.         DestroyTickets();
  914.     quit();
  915.     return (FALSE);
  916. }
  917.  
  918. /*
  919.  *    HandleMenuCommand - preform a command denoted by the arguments.
  920.  *        mResult - the result of the menu event
  921.  *        modifiers- modifiers from the menu event
  922.  */
  923.  
  924. void HandleMenuCommand( long mResult, short modifiers)
  925. {
  926.     register short i;
  927.     short theItem, theMenu;
  928.     Boolean doWrap;
  929.  
  930.     theMenu = mResult >> 16;
  931.     theItem = mResult & 0xffff;
  932.     switch(theMenu) {
  933.     case appleMenu:
  934.         if (theItem==1)                /* About Dialog */
  935.             applAbout();
  936.         else
  937.           {
  938.             Str255
  939.                 name;
  940.             GetItem(myMenus[0], theItem, name);        /* Desk accessory */
  941.             OpenDeskAcc(name);
  942.           }
  943.         break;
  944.  
  945.     case fileMenu:
  946.     case NfileMenu:
  947.         switch(theItem) {            
  948.             
  949.         case FLopen:
  950.             PresentOpenConnectionDialog();                    /* Open a connection */                
  951.             break;
  952.  
  953.         case FLclose:                                    /* Close a connection */
  954.             if (!(modifiers &  optionKey))
  955.                 CloseAWindow(FrontWindow());
  956.             else
  957.             {
  958.                 Boolean die = TRUE;
  959.                 if (numberLiveConnections())
  960.                     die = AskUserAlert(CLOSE_ALL_WINDOWS_Q, FALSE);
  961.                 
  962.                 if (die) 
  963.                 {
  964.                     for (i = TelInfo->numwindows - 1; i >= 0; i--) 
  965.                     {
  966.                         netclose(screens[i].port);
  967.                         destroyport(i);
  968.                     }
  969.                 }
  970.                 else
  971.                     break;
  972.             }
  973.             break;
  974.  
  975.         case FLload:                                /* Load a set */
  976.             LoadSet();
  977.             break;
  978.         case FLsave:                                /* Save a set */
  979.             if (TelInfo->numwindows<1) break;
  980.             SaveSet();
  981.             break;
  982.         case FLbin:                                    /* Toggle MacBinary on/off */
  983.             TelInfo->MacBinary = !TelInfo->MacBinary;
  984.             if (TelInfo->MacBinary) {
  985.                 CheckItem(myMenus[Fil], FLbin,TRUE);
  986.                 }
  987.             else {
  988.                 CheckItem(myMenus[Fil], FLbin,FALSE);
  989.                 }
  990.             break;
  991.  
  992.         case FLlog:                                        /* Toggle FTP window on/off*/
  993.             TelInfo->ftplogon=!TelInfo->ftplogon;
  994.             if(TelInfo->ftplogon) {
  995.                 CheckItem(myMenus[Fil],FLlog,TRUE);
  996.                 RSshow(ftplog->vs);
  997.                 SelectWindow(ftplog->wind);
  998.                 }
  999.             else {
  1000.                 CheckItem(myMenus[Fil],FLlog,FALSE);
  1001.                 RShide(ftplog->vs);
  1002.                 }
  1003.             break;
  1004.  
  1005.         case FLprint:                                /* Print Selection (or gr) */
  1006.             PrintSelection();
  1007.             break;
  1008.  
  1009.         case FLpset:                                    /* Set up for printer */
  1010.             PrintPageSetup();
  1011.             break;
  1012.  
  1013.         case FLquit:
  1014.             (void) HandleQuit();
  1015.             break;
  1016.  
  1017.         }
  1018.         break;
  1019.  
  1020.     case editMenu:
  1021.     case NeditMenu:
  1022.         if (!SystemEdit(theItem-1)) {                /* Is this mine? */
  1023.             switch(theItem) {
  1024.             case EDcopy:                            /* Copy */
  1025.                 i = MacRGfindwind(FrontWindow());    /* is ICR window? */
  1026.                 if (i >= 0)
  1027.                     MacRGcopy(FrontWindow());        /* copy the ICR window */
  1028.                 else {
  1029.                     i=RGgetdnum(FrontWindow());
  1030.                     if (i>-1)                        /* Copy Graphics */
  1031.                         copyGraph( i);
  1032.                     else                            /* Copy Text */
  1033.                         if ( (i=RSfindvwind(FrontWindow())) >-1)
  1034.                             copyText( i);
  1035.                 }
  1036.                 break;
  1037.  
  1038.             case EDcopyt:                            /* Copy Table */
  1039.                 /* 
  1040.                 *  tech note #180 trick to get MultiFinder to pay attention 
  1041.                 */
  1042.                 if (!SystemEdit(EDcopy-1)) {        /* tell it we did a copy */
  1043.                     i=RGgetdnum(FrontWindow());
  1044.                     if (i>-1)            /* Copy Graphics */
  1045.                         copyGraph( i);
  1046.                     else                /* Copy Text */
  1047.                         if ( (i=RSfindvwind(FrontWindow())) >-1)
  1048.                             copyTable( i);
  1049.                 }
  1050.                 break;
  1051.  
  1052.             case EDpaste:                            /* Paste */
  1053.                 if (TelInfo->numwindows<1)
  1054.                         break;
  1055.                     else paste();            /* Paste if there is a wind to do to*/
  1056.                 break;
  1057.             case EDmacros:                            /* Set them Macros */
  1058.                 Macros();
  1059.                 break;
  1060.             default:
  1061.                 break;
  1062.             }
  1063.         }
  1064.         break;
  1065.  
  1066.     case connMenu:
  1067.     case NconnMenu:
  1068.         if (theItem == COnext) 
  1069.         {
  1070.             if (TelInfo->numwindows >1) 
  1071.             {
  1072.                 short    scratchshort;
  1073.                 if (!(modifiers &  shiftKey)) //go forward
  1074.                 {
  1075.                     scratchshort = WindowPtr2ScreenIndex(FrontWindow()) + 1;
  1076.                     // Skip over inactive connections
  1077.                     while(    (screens[scratchshort].active != CNXN_ACTIVE) &&
  1078.                             (screens[scratchshort].active != CNXN_ISCORPSE) &&
  1079.                             (scratchshort <= TelInfo->numwindows+1))                        
  1080.                         scratchshort++;
  1081.                     if ((scratchshort < 0) || (scratchshort >= TelInfo->numwindows))
  1082.                         scratchshort = 0;
  1083.                 }
  1084.                 else //go backward
  1085.                 {
  1086.                     scratchshort = WindowPtr2ScreenIndex(FrontWindow()) - 1;
  1087.                     // Skip over inactive connections
  1088.                     while(    (screens[scratchshort].active != CNXN_ACTIVE) &&
  1089.                             (screens[scratchshort].active != CNXN_ISCORPSE) &&
  1090.                             (scratchshort >= 0))                        
  1091.                         scratchshort--;
  1092.                     if ((scratchshort < 0) || (scratchshort >= TelInfo->numwindows))
  1093.                         scratchshort = TelInfo->numwindows - 1;
  1094.                 }        
  1095.                 SelectWindow(screens[scratchshort].wind);
  1096.             }
  1097.             break;
  1098.         }
  1099.         
  1100.         if (theItem == COtitle)    {
  1101.             ChangeWindowName(FrontWindow());
  1102.             break;
  1103.             }
  1104.             
  1105.         if (theItem >= FIRST_CNXN_ITEM) {
  1106.             if ((theItem - FIRST_CNXN_ITEM-1)>(TelInfo->numwindows+1)) break;  /* rotten danish */
  1107.             if (screens[theItem - FIRST_CNXN_ITEM].active != CNXN_ACTIVE) {
  1108.                 displayStatus(theItem - FIRST_CNXN_ITEM);    /* Tell them about it..... */
  1109.                 break;
  1110.                 }
  1111.             else {
  1112.                 HiliteWindow(screens[scrn].wind, FALSE);
  1113.                 changeport(scrn,(theItem - FIRST_CNXN_ITEM));
  1114.                 if (!(modifiers &  optionKey)) SelectWindow(screens[scrn].wind);
  1115.                 else HiliteWindow(screens[scrn].wind, TRUE);
  1116.                 }
  1117.             }
  1118.         break;
  1119.  
  1120.     case netMenu:
  1121.     case NnetMenu:
  1122.         switch(theItem) {
  1123.         case NEftp:                                        /* Send FTP command */
  1124.         case NEip:                                        /* Send IP Number */
  1125.             if (TelInfo->numwindows<1) break;
  1126.             {    char tmpout[30];                        /* Basically the same except for */
  1127.                 unsigned char tmp[4];                    /* The ftp -n phrase in NEftp */
  1128.  
  1129.                 if (screens[scrn].echo && (screens[scrn].kblen>0)) {
  1130.                     netwrite( screens[scrn].port, screens[scrn].kbbuf,
  1131.                                 screens[scrn].kblen);/* if not empty send buffer */
  1132.                     screens[scrn].kblen=0;
  1133.                     }
  1134.                 netgetip(tmp);
  1135.                 if (theItem == NEftp) {
  1136.                     if ((gFTPServerPrefs->ServerState == 1) && !(modifiers & shiftKey))
  1137.                         sprintf(tmpout,"ftp -n %d.%d.%d.%d\015\012",tmp[0],tmp[1],tmp[2],tmp[3]);
  1138.                     else
  1139.                         sprintf(tmpout,"ftp %d.%d.%d.%d\015\012",tmp[0],tmp[1],tmp[2],tmp[3]);
  1140.                     }
  1141.                 else
  1142.                     sprintf(tmpout,"%d.%d.%d.%d",tmp[0],tmp[1],tmp[2],tmp[3]);
  1143.                 netwrite(screens[scrn].port,tmpout,strlen(tmpout));
  1144.                 if (screens[scrn].echo)
  1145.                     VSwrite(screens[scrn].vs,tmpout, strlen(tmpout));
  1146.             }
  1147.             break;
  1148.  
  1149.         case NEayt:                                /* Send "Are You There?"*/
  1150.             if (TelInfo->numwindows<1) break;
  1151.             netpush(screens[scrn].port);
  1152.             netwrite(screens[scrn].port, "\377\366",2);
  1153.             break;
  1154.  
  1155.         case NEao:                                /* Send "Abort Output"*/
  1156.             if (TelInfo->numwindows<1) break;
  1157.             netpush(screens[scrn].port);
  1158.             netwrite(screens[scrn].port, "\377\365",2);
  1159.             screens[ scrn].timing = 1;                        /* set emulate to TMwait */
  1160.             netwrite(screens[scrn].port, "\377\375\006",3);        /* send TM */
  1161.             break;
  1162.  
  1163.         case NEinter:                                /* Send "Interrupt Process"*/
  1164.             if (TelInfo->numwindows<1) break;
  1165.             netpush(screens[scrn].port);
  1166.             netwrite(screens[scrn].port, "\377\364",2);
  1167.             screens[ scrn].timing = 1;                        /* set emulate to TMwait */
  1168.             netwrite(screens[scrn].port, "\377\375\006",3);        /* send TM */
  1169.             break;
  1170.  
  1171.         case NEec:                                /* Send "Erase Character"*/
  1172.             if (TelInfo->numwindows<1) break;
  1173.             netpush(screens[scrn].port);
  1174.             netwrite(screens[scrn].port, "\377\367",2);
  1175.             break;
  1176.  
  1177.         case NEel:                                /* Send "Erase Line"*/
  1178.             if (TelInfo->numwindows<1) break;
  1179.             netpush(screens[scrn].port);
  1180.             netwrite(screens[scrn].port, "\377\370",2);
  1181.             break;
  1182.             
  1183.         case NEscroll:                            /* Suspend Network */
  1184.             TelInfo->ScrlLock=!TelInfo->ScrlLock;
  1185.             if (TelInfo->ScrlLock) 
  1186.                 CheckItem(myMenus[Net], NEscroll,TRUE);
  1187.             else 
  1188.                 CheckItem(myMenus[Net], NEscroll,FALSE);
  1189.             break;
  1190.  
  1191.         case NEnet:                                /* Show Network Numbers */
  1192.             showNetNumbers();
  1193.             break;
  1194.  
  1195.         default:
  1196.             break;
  1197.         }
  1198.         break;
  1199.  
  1200.     case termMenu:
  1201.     case NtermMenu:
  1202.         switch(theItem) {
  1203.  
  1204.         case EMbs:                                /* Backspace for backspace  */
  1205.             if (TelInfo->numwindows<1) break;
  1206.             CheckItem(myMenus[Emul], EMbs+screens[scrn].bsdel,FALSE);
  1207.             screens[scrn].bsdel=0;
  1208.             CheckItem(myMenus[Emul], EMbs+screens[scrn].bsdel,TRUE);
  1209.             break;
  1210.         
  1211.         case EMdel:                                /* Delete for backspace */
  1212.             if (TelInfo->numwindows<1) break;
  1213.             CheckItem(myMenus[Emul], EMbs+screens[scrn].bsdel,FALSE);
  1214.             screens[scrn].bsdel=1;
  1215.             CheckItem(myMenus[Emul], EMbs+screens[scrn].bsdel,TRUE);
  1216.             break;
  1217.  
  1218.         case EMecho:                                /* Toggle Local Echo (if poss.) */
  1219.             if (TelInfo->numwindows < 1) break;
  1220.             if (screens[scrn].echo && (screens[scrn].kblen>0)) {
  1221.                 netwrite( screens[scrn].port, screens[scrn].kbbuf,
  1222.                             screens[scrn].kblen);    /* if not empty send buffer */
  1223.                 screens[scrn].kblen=0;
  1224.                 }
  1225.             screens[scrn].echo= !screens[scrn].echo;    /* toggle */
  1226.             if (screens[scrn].echo) {                    /* LOCAL ECHO */
  1227.                 send_dont(screens[scrn].port,1);
  1228.                 CheckItem(myMenus[Emul],EMecho,TRUE);
  1229.                 }
  1230.             else {                                        /* REMOTE ECHO */
  1231.                 send_do(screens[scrn].port,1);
  1232.                 CheckItem(myMenus[Emul],EMecho,FALSE);
  1233.                 }
  1234.             break;
  1235.             
  1236.         case EMwrap:                                /* wrap mode */
  1237.             if (TelInfo->numwindows < 1) break;
  1238.             if (!screens[scrn].wrap) {                /* is off, turn on */
  1239.                 screens[scrn].wrap = 1;
  1240.                 CheckItem( myMenus[Emul],EMwrap, TRUE);
  1241.                 VSwrite(screens[scrn].vs, "\033[?7h",5);    /* kick emulator */
  1242.                 }
  1243.             else {
  1244.                 screens[scrn].wrap = 0;
  1245.                 CheckItem( myMenus[Emul],EMwrap, FALSE);
  1246.                 VSwrite(screens[scrn].vs, "\033[?7l",5);
  1247.                 }
  1248.             break;
  1249.         
  1250.         case EMarrowmap:                                        /* JMB */
  1251.             if (TelInfo->numwindows < 1) break;                    /* JMB */
  1252.             screens[scrn].arrowmap = !screens[scrn].arrowmap;    /* JMB */
  1253.             if (screens[scrn].arrowmap)                            /* JMB */
  1254.                 CheckItem( myMenus[Emul], EMarrowmap, TRUE);    /* JMB */
  1255.             else                                                /* JMB */
  1256.                 CheckItem( myMenus[Emul], EMarrowmap, FALSE);    /* JMB */
  1257.             break;                                                /* JMB */
  1258.             
  1259.         case EMpgupdwn:
  1260.             if (TelInfo->numwindows < 1) break;                    /* JMB */
  1261.             screens[scrn].pgupdwn = !screens[scrn].pgupdwn;        /* JMB */
  1262.             if (screens[scrn].pgupdwn)                            /* JMB */
  1263.                 CheckItem( myMenus[Emul], EMpgupdwn, TRUE);        /* JMB */
  1264.             else                                                /* JMB */
  1265.                 CheckItem( myMenus[Emul], EMpgupdwn, FALSE);    /* JMB */
  1266.             break;                                                /* JMB */
  1267.             
  1268.         case EMscroll:                                        /* Scrollback on CLS */
  1269.             if (TelInfo->numwindows<1) break;
  1270.             screens[scrn].ESscroll = !screens[scrn].ESscroll;
  1271.             VSscrolcontrol( screens[scrn].vs, -1, screens[scrn].ESscroll);
  1272.             if (screens[scrn].ESscroll)
  1273.                 CheckItem(myMenus[Emul],EMscroll, TRUE);
  1274.             else
  1275.                 CheckItem(myMenus[Emul],EMscroll, FALSE);
  1276.             break;
  1277.             
  1278.         case EMpage:                                    /* TEK page command */
  1279.             if (TelInfo->numwindows<1) break;
  1280.             parse( &screens[scrn],  (unsigned char *) "\033\014",2);    /* BYU LSC */
  1281.             break;
  1282.  
  1283.         case EMclear:                                /* BYU 2.4.8 - Clear on TEK page */
  1284.             if (TelInfo->numwindows<1) break;
  1285.             screens[scrn].tekclear = !screens[scrn].tekclear;
  1286.             if (screens[scrn].tekclear)
  1287.                 CheckItem(myMenus[Emul],EMclear, TRUE);
  1288.             else
  1289.                 CheckItem(myMenus[Emul],EMclear, FALSE);
  1290.             break;
  1291.  
  1292.         case EMscreensize:
  1293.             if (TelInfo->numwindows<1) break;        /* NCSA: SB */
  1294.             SetScreenDimensions((short)scrn);        /* NCSA: SB */
  1295.             break;
  1296.  
  1297.         case EMreset:                                    /* Reset Screen */
  1298.             //RESTORE WRAP AFTER THE RESET!!! BUGG
  1299.             if (TelInfo->numwindows<1) break;
  1300.             doWrap = screens[scrn].wrap;
  1301.             VSreset(screens[scrn].vs);                    /* Reset it */
  1302.             screens[scrn].timing=0;
  1303.             if (doWrap)
  1304.                 VSwrite(screens[scrn].vs, "\033[?7h",5);
  1305.             else
  1306.                 CheckItem( myMenus[Emul],EMwrap, FALSE);
  1307.             break;
  1308.         case EMjump:                                    /* Jump Scroll */
  1309.             if (TelInfo->numwindows<1) break;
  1310.             FlushNetwork(scrn);                            /* Flush it */
  1311.             break;
  1312.             
  1313.         case EMsetup:                            /* need dialog to enter new key values */
  1314.             setupkeys();
  1315.             break;
  1316.  
  1317.         case EMcolor:                                        /* Set color */
  1318.             if (TelInfo->numwindows<1) break;
  1319.             if (TelInfo->haveColorQuickDraw)
  1320.                 RScprompt(screens[scrn].vs);    
  1321.             break;
  1322.         case EMAnsiColor:
  1323.             if (TelInfo->haveColorQuickDraw)
  1324.                 AnsiPrompt();
  1325.                 RSUpdatePalette();
  1326.             return;    
  1327.         case EMcapture:                                            /* BYU 2.4.18 - Capture session to file */
  1328.             if (VSiscapturing(screens[scrn].vs)) {                /* BYU 2.4.18 */
  1329.                 CloseCaptureFile(screens[scrn].vs);                /* BYU 2.4.18 */
  1330.             } else {                                            /* BYU 2.4.18 */
  1331.                 if(VSopencapture(scrn, screens[scrn].vs))        /* BYU 2.4.18 */
  1332.                     CheckItem(myMenus[Emul], EMcapture,TRUE);    /* BYU 2.4.18 */
  1333.             }                                                    /* BYU 2.4.18 */
  1334.  
  1335.             break;                                                /* BYU 2.4.18 */
  1336. #define    SPEECH
  1337. #ifdef    SPEECH
  1338.         case EMspeaking:
  1339.             AnnoyingSpeechMode(screens[scrn].vs);
  1340.             break;
  1341. #endif
  1342.  
  1343.         default:
  1344.             break;
  1345.         }
  1346.         break;
  1347.     case fontMenu:
  1348.         if (TelInfo->numwindows>0) {
  1349.             short     itemFontNum;
  1350.             Str255     temp;
  1351.             
  1352.             GetItem( myMenus[Font], theItem, temp);
  1353.             GetFNum( temp, &itemFontNum);
  1354.             
  1355.             RSchangefont( screens[scrn].vs, itemFontNum, 0);
  1356.             CheckFonts();
  1357.             }
  1358.         break;
  1359.     case sizeMenu:
  1360.         if (TelInfo->numwindows>0) 
  1361.         {
  1362.             long    itemFontSize;
  1363.             short     currentSize, junk;
  1364.             Str255     temp;
  1365.             short     numOfItems;
  1366.             
  1367.             numOfItems = CountMItems(myMenus[Sizem]);
  1368.             if (numOfItems == theItem) //use picked 'other...'
  1369.             {
  1370.                 RSgetfont(screens[scrn].vs, &junk, ¤tSize);    
  1371.                 itemFontSize = SetOtherFontSize(currentSize);
  1372.             }
  1373.             else
  1374.             {
  1375.                 GetItem( myMenus[Sizem], theItem, temp);    /* JMB 2.6 -- Much safer to do it */
  1376.                 StringToNum(temp, &itemFontSize);        /*                this way! */
  1377.             }
  1378.  
  1379.             RSchangefont( screens[scrn].vs, -1, itemFontSize);
  1380.             CheckFonts();
  1381.         }
  1382.         break;
  1383.     case opspecMenu:                                            // JMB
  1384.         OpenPortSpecial(myMenus[OpSpec], theItem);                // JMB
  1385.         break;                                                    // JMB
  1386.     case prefsMenu:
  1387.         switch(theItem) {
  1388.             case prfGlobal:
  1389.                 Cenviron();
  1390.                 break;
  1391.             case prfFTP:
  1392.                 Cftp();
  1393.                 break;
  1394.             case prfSess:
  1395.                 EditConfigType(SESSIONPREFS_RESTYPE, &EditSession);
  1396.                 CheckOpSpecSubmenu();
  1397.                 break;
  1398.             case prfTerm:
  1399.                 EditConfigType(TERMINALPREFS_RESTYPE, &EditTerminal);
  1400.                 break;
  1401.             case prfFTPUser:
  1402.                 EditConfigType(FTPUSER, &EditFTPUser);
  1403.             }
  1404.         break;
  1405.     case transMenu:
  1406.         if (TelInfo->numwindows>0) {
  1407.             CheckNational(theItem-1);        // Set up the menu
  1408.             transBuffer(screens[scrn].national, theItem-1);    // Translate the scrollback buffer
  1409.             // and redraw the screen
  1410.             VSredraw(screens[scrn].vs,0,0,VSmaxwidth(screens[scrn].vs),VSgetlines(screens[scrn].vs)-1);    /* LU */
  1411.             screens[scrn].national = theItem-1;
  1412.             }
  1413.         break;
  1414.     case keyMenu:
  1415.         KeyMenu(theItem);
  1416.         break;
  1417.     case funcMenu:
  1418.         FuncMenu(theItem);
  1419.         break;
  1420. #ifdef    SPEECH
  1421.     case speechMenu:
  1422.         HandleSpeechMenu(theItem);
  1423.         break;
  1424. #endif    /* SPEECH */
  1425.     default:
  1426.         break;
  1427.     
  1428.     }
  1429.     HiliteMenu(0);
  1430.   } /* HandleMenuCommand */
  1431.  
  1432. //    Take the user's new translation choice and make sure the proper tables exist to do 
  1433. //        the translations.  If there is a problem, return the default translation as the chouce.
  1434. void    CheckNational(short choice)
  1435. {
  1436.     short i;
  1437.             
  1438.     for(i=1; i<=(nNational+1);i++)
  1439.         if ((choice+1) == i)                    /* Check the Current NatLang */
  1440.             CheckItem( myMenus[National], i, TRUE);
  1441.         else
  1442.             CheckItem( myMenus[National], i, FALSE);
  1443.  
  1444. }
  1445.  
  1446. /*
  1447.  *    extractmenu - remove a connection from the menu.
  1448.  */
  1449.  
  1450. void extractmenu(short screen)
  1451. {
  1452.     DelMenuItem(myMenus[Conn], screen + FIRST_CNXN_ITEM);
  1453.     AdjustMenus();
  1454. }
  1455.  
  1456. /*
  1457.  *    addinmenu - add a connection's name to the menu in position pnum. (name is
  1458.  *        an str255 pointed at by temps).
  1459.  */
  1460.  
  1461. void addinmenu( short screen, Str255 temps, char mark)
  1462. {
  1463.     InsMenuItem(myMenus[Conn], "\pDoh", (screen-1) + FIRST_CNXN_ITEM);
  1464.     SetItem(myMenus[Conn], screen + FIRST_CNXN_ITEM, temps);        // Avoid metas
  1465.     SetItemMark( myMenus[Conn], screen + FIRST_CNXN_ITEM, mark);
  1466.     AdjustMenus();
  1467. }
  1468.  
  1469. /*    Set the item mark for <scrn> to opening connection */
  1470. void SetMenuMarkToOpeningForAGivenScreen( short scrn)
  1471. {
  1472.     unsigned char c=0xa5;
  1473.  
  1474.     SetItemMark( myMenus[Conn], scrn + FIRST_CNXN_ITEM, c );
  1475. }
  1476.  
  1477. /*    Set the item mark for <scrn> to opened connection */
  1478. void SetMenuMarkToLiveForAGivenScreen( short scrn)
  1479. {
  1480.     SetItemMark( myMenus[Conn], scrn + FIRST_CNXN_ITEM, noMark);
  1481.     AdjustMenus();
  1482. }
  1483.  
  1484. void DoTheMenuChecks(void)
  1485. {
  1486.     short    active;
  1487.     short    windownum;
  1488.  
  1489.     if (TelInfo->numwindows>0)
  1490.         {
  1491.         EnableItem( myMenus[Conn],0);
  1492.         if (gApplicationPrefs->KeyPadAndFuncMenus) {            /* Baylor */
  1493.             EnableItem(myMenus[Keypad], 0);            /* Baylor */
  1494.             EnableItem(myMenus[Function], 0);        /* Baylor */
  1495.             }
  1496.         DrawMenuBar();
  1497.         }
  1498.  
  1499.     else 
  1500.         {
  1501.         DisableItem(myMenus[Conn],0);
  1502.         if (gApplicationPrefs->KeyPadAndFuncMenus) {            /* Baylor */
  1503.             DisableItem(myMenus[Keypad], 0);        /* Baylor */
  1504.             DisableItem(myMenus[Function], 0);        /* Baylor */
  1505.             }
  1506.         DrawMenuBar();
  1507.         }
  1508.  
  1509.     active =0;
  1510.     
  1511.     for (windownum=0;windownum<TelInfo->numwindows;windownum++)
  1512.         if (screens[windownum].active == CNXN_ACTIVE) active++;
  1513.         
  1514.     if (active<2)    
  1515.         DisableItem(myMenus[Conn],COnext);
  1516.     else EnableItem(myMenus[Conn],COnext);
  1517.  
  1518.     if (!active)
  1519.         {
  1520.         DisableItem(myMenus[Edit],EDpaste);
  1521.         DisableItem(myMenus[Emul],0);
  1522.         DrawMenuBar();
  1523.         }
  1524.     else 
  1525.         {
  1526.         EnableItem(myMenus[Edit],EDpaste);
  1527.         EnableItem( myMenus[Emul],0);
  1528.         DrawMenuBar();
  1529.         }
  1530. }
  1531.  
  1532.  
  1533.  
  1534. /*--------------------------------------------------------------------------*/
  1535. /* SetupMenusForSelection                                                    */
  1536. /* If there is a selection on screen, then let the user copy and print.        */
  1537. /* If not, then, oh well....just disable the menus and forget about it        */
  1538. /* ...and to think that this good stuff USED to be in rsmac.c.                 */
  1539. /* This is called from RSselect after the user clicks in the window, and     */
  1540. /* was moved here for modularity    - SMB                                    */
  1541. /*--------------------------------------------------------------------------*/
  1542. void SetMenusForSelection (short selected)                    /* NCSA: SB */    
  1543. {                                                            /* NCSA: SB */
  1544.     if (!selected)                                            /* NCSA: SB */
  1545.         {                                                    /* NCSA: SB */
  1546.         DisableItem(myMenus[Fil],FLprint);                    /* NCSA: SB */
  1547.         DisableItem(myMenus[Edit],EDcopy);                    /* NCSA: SB */
  1548.         DisableItem(myMenus[Edit],EDcopyt);                    /* NCSA: SB */
  1549.         }                                                    /* NCSA: SB */
  1550.     else                                                     /* NCSA: SB */
  1551.         {                                                    /* NCSA: SB */
  1552.         EnableItem(myMenus[Fil],FLprint);                    /* NCSA: SB */
  1553.         EnableItem(myMenus[Edit],EDcopy);                    /* NCSA: SB */
  1554.         EnableItem(myMenus[Edit],EDcopyt);                    /* NCSA: SB */
  1555.         }                                                    /* NCSA: SB */
  1556.         
  1557.     AdjustSpeechMenu(selected);
  1558. }                                                            /* NCSA: SB */
  1559.  
  1560.  
  1561. long SetOtherFontSize(short currentSize)
  1562. {
  1563.     DialogPtr    dtemp;
  1564.     Str255 currentSizeStr, newSizeStr;
  1565.     long newSize;
  1566.     Boolean GoodValue;
  1567.     short ditem;
  1568.     
  1569.     dtemp=GetNewMyDialog( OtherFontDLOG, NULL, kInFront, (void *)ThirdCenterDialog); 
  1570.     InitCursor();
  1571.  
  1572.     GoodValue = 0;
  1573.     
  1574.     while (!GoodValue)
  1575.     {
  1576.         GoodValue = TRUE;
  1577.         NumToString((long) currentSize, currentSizeStr);
  1578.         SetTEText(dtemp, FontSizeTE, currentSizeStr);
  1579.     
  1580.         ditem = 0;
  1581.         while(ditem != DLOGOk && ditem != DLOGCancel)
  1582.             ModalDialog(DLOGwOK_CancelUPP, &ditem);
  1583.     
  1584.         if (ditem == DLOGCancel) {
  1585.             DisposeDialog( dtemp);
  1586.             return currentSize;
  1587.         }
  1588.     
  1589.         GetTEText(dtemp, FontSizeTE, newSizeStr);
  1590.         StringToNum(newSizeStr, &newSize);
  1591.     
  1592.         if (newSize < 9)
  1593.             GoodValue = FALSE;
  1594.         
  1595.         if (!GoodValue) SysBeep(4);
  1596.     }
  1597.     DisposeDialog( dtemp);
  1598.     
  1599.     return (newSize);
  1600. }
  1601. /*----------------------------------------------------------------------*/
  1602. /* NCSA: SB - SetColumnWidth                                            */
  1603. /*    Allow the user to FINALLY pick how many columns he wants on the     */
  1604. /*    screen.  Set up a dialog box to pick the # of columns, and then        */
  1605. /*    size-up the Telnet screen accordingly.  NOTE: The user still needs    */
  1606. /*     to do a "resize", unless he is using NAWS                            */
  1607. /*----------------------------------------------------------------------*/
  1608. void SetScreenDimensions(short scrn)
  1609. {
  1610.     DialogPtr    dtemp;
  1611.     Str255        ColumnsSTR, LinesSTR;
  1612.     long        columns, lines;
  1613.     short        ditem, notgood;
  1614.     
  1615.     dtemp=GetNewMyDialog( SizeDLOG, NULL, kInFront, (void *)ThirdCenterDialog); 
  1616.     
  1617.     SetCursor(theCursors[normcurs]);
  1618.  
  1619.     notgood = 1;
  1620.     lines = VSgetlines(screens[scrn].vs);
  1621.     columns = VSgetcols(screens[scrn].vs) + 1;
  1622.     
  1623.     while (notgood) {
  1624.         notgood = 0;                                /* Default to good */
  1625.         NumToString(columns, ColumnsSTR);
  1626.         NumToString(lines, LinesSTR);
  1627.         SetTEText(dtemp, ColumnsNumber, ColumnsSTR);
  1628.         SetTEText(dtemp, LinesNumber, LinesSTR);
  1629.         SelIText( dtemp, ColumnsNumber, 0, 32767);
  1630.     
  1631.         ditem = 3;
  1632.         while(ditem>2)
  1633.             ModalDialog(DLOGwOK_CancelUPP, &ditem);
  1634.     
  1635.         if (ditem == DLOGCancel) {
  1636.             DisposeDialog( dtemp);
  1637.             return;
  1638.             }
  1639.         
  1640.         GetTEText(dtemp, ColumnsNumber, ColumnsSTR);
  1641.         StringToNum(ColumnsSTR, &columns);
  1642.         GetTEText(dtemp, LinesNumber, LinesSTR);
  1643.         StringToNum(LinesSTR, &lines);
  1644.         
  1645.         if (columns < 10) {
  1646.             columns = 10;
  1647.             notgood = 1;
  1648.             }
  1649.         else if (columns > 132) {
  1650.             columns = 132;
  1651.             notgood = 1;
  1652.             }
  1653.  
  1654.         if (lines < 10) {
  1655.             lines = 10;
  1656.             notgood = 1;
  1657.             }
  1658.         else if (lines > 200) {
  1659.             lines = 200;
  1660.             notgood = 1;
  1661.             }
  1662.         
  1663.         if (notgood) SysBeep(4);
  1664.     }
  1665.     
  1666.     DisposeDialog( dtemp);
  1667.     if (VSsetlines( screens[scrn].vs, lines) < 0) 
  1668.         OutOfMemory(-4);
  1669.     else
  1670.     {
  1671.         RScalcwsize( screens[scrn].vs, columns);
  1672.         if (screens[scrn].naws)
  1673.             SendNAWSinfo(&screens[scrn], (short)columns, (short)lines);
  1674.      }
  1675.     updateCursor(1);
  1676. }
  1677.  
  1678. void    ChangeWindowName(WindowPtr    theWindow)
  1679. {
  1680.     DialogPtr    dptr;
  1681.     short        itemHit;
  1682.     Str255        theName;
  1683.  
  1684.     if( theWindow != NULL) {
  1685.         InitCursor();
  1686.         dptr = GetNewMySmallDialog(WinTitlDLOG, NULL, kInFront, (void *)ThirdCenterDialog );
  1687.  
  1688.         GetWTitle(theWindow, theName); 
  1689.         SetTEText( dptr, kWinNameTE, theName);
  1690.         SelIText( dptr, kWinNameTE, 0, 250 );
  1691.  
  1692.         itemHit = 0;
  1693.         while(itemHit != DLOGOk && itemHit != DLOGCancel)
  1694.             ModalDialog(DLOGwOK_CancelUPP, &itemHit);
  1695.         
  1696.         if(itemHit == DLOGOk) {
  1697.             GetTEText(dptr, kWinNameTE, theName);
  1698.             set_new_window_name(theName, theWindow);
  1699.             }
  1700.             
  1701.         DisposDialog(dptr);
  1702.         }
  1703. }
  1704.  
  1705. void    set_new_window_name(Str255 theName, WindowPtr theWindow)
  1706. {
  1707.     short    i;
  1708.     
  1709.     if(theName[0]) {
  1710.         i = WindowPtr2ScreenIndex(theWindow);
  1711.         if (i >= 0) {
  1712.             i += FIRST_CNXN_ITEM;
  1713.             SetWTitle(theWindow, theName);
  1714.             SetItem(myMenus[Conn], i, theName);
  1715.             }
  1716.         }
  1717. }
  1718.